How Anyone Can Plug LLMs(MCP)? | 매거진에 참여하세요

How to get started with tool-using agents like Claude, even if you're not a developer

What is MCP—and Why Should You Care?

Model Context Protocol (MCP) is an open standard introduced by Anthropic to make Large Language Models (LLMs)

like Claude capable of interacting with real-world tools and data sources.

Think of it as a plug-and-play framework that allows your AI agent to not just “chat,” but also take action

—create calendar events, fetch GitHub issues, or manage a to-do list.

In short, it’s how Claude (or any future model) becomes a doer, not just a talker.

But don’t worry—the name “Model Context Protocol” sounds way scarier than it is. You don’t need to be a developer to understand the logic.

What Does the Agent Actually Do?

Let’s imagine you say:

“Hey Claude, can you create a new GitHub issue for me?”

Here’s what happens behind the scenes:

1. 1. You ask Claude something that requires action

2. 2. Claude recognizes this is an external task → “I need to talk to a GitHub plugin.”

3. 3. Claude formats a request using the MCP structure:

{
  "tool": "github",
  "action": "create_issue",
  "parameters": {
    "repo": "acme/project-x",
    "title": "Login page bug",
    "body": "Clicking login throws a 500 error."
  }
}

}

4. 4. Your MCP server sends this to your GitHub plugin (via API)

5. 5. The plugin completes the task → returns confirmation

6. 6. Claude then tells you:

“Issue created. Here’s the link.”

The Standard Schema: Simple and Predictable

The magic is in its simplicity:

• tool: What plugin/tool to use (calander, notion_api, github)

• action: What to do (create_event, get_task, submit_form)

• parameters: The details needed for the action

{
  "tool": "calendar",
  "action": "create_event",
  "parameters": {
    "title": "Weekly sync",
    "date": "2025-05-15",
    "time": "10:00"
  }
}

Why use this structure?

• It’s safe for LLMs to trigger only authorized actions

• Easy for backends to parse and route

• Works seamlessly across tools, APIs, and services

• Compatible with OpenAI’s function calling, Meta’s LLaMA Agents, and more

Defining Your Own Plugin (Tool)

Let’s say you run a to-do list app and want Claude to interact with it.

You define your tool like this:

{
  "name": "todo_service",
  "description": "Manage personal tasks",
  "functions": [
    {
      "name": "create_task",
      "description": "Create a new task",
      "parameters": {
        "type": "object",
        "properties": {
          "title": { "type": "string" },
          "due_date": { "type": "string", "format": "date" }
        },
        "required": ["title"]
      }
    }
  ]
}

Once Claude is given this schema, it knows how to call your API by simply interpreting natural language.

What About Authentication?

There are two main ways to handle security when your plugin needs access to a real user account:

2. Server-side API key (fixed)

3. 
   Useful for internal tools or shared backend APIs.
   Add a bearer token like:

4. Authorization: Bearer YOUR_SERVER_API_KEY

7. User-level OAuth
   

8. More advanced.
   Store each user’s access token in your backend, and when Claude calls the plugin, pass the token with the request:

{
  "tool": "todo_service",
  "action": "create_task",
  "parameters": {
    "title": "Prepare for Monday demo",
    "due_date": "2025-05-14"
  },
  "auth": {
    "type": "bearer",
    "token": "user123-access-token"
  }
}

Claude itself doesn't read the token. Your backend inserts it into the API request headers.

Wait—How Can I Actually Try This?

The easiest way is: just start. Explore Claude’s developer resources:
https://claude.ai/download

1. 

   Define a sample plugin using JSON schema (even a simple todo api)

3. Spin up a simple REST server or use tools like Replit + Ngrok to expose it

4. Register the tool via Claude’s tool-use API or console

6. Say:

   “Add ‘buy milk’ to my to-do list”

You’ll be shocked how real it feels.

Available MCP Plugins for Claude

TL;DR – Why MCP Matters

• It turns LLMs into tool-using agents

• It uses a simple JSON structure for tool, action, and parameters

• It enables safe, controllable, real-world integration

• It opens the door for custom plugins—without needing a marketplace

• And yes, even non-devs can build something meaningful with it

Final Thought: Everyone Can Build with LLMs Now

You don’t need to understand everything about API gateways, schema validation, or OAuth flows to start.

You just need to:

✅ Understand the structure
✅ Know what your tool is supposed to do
✅ Define it clearly
✅ Try it out

This is the foundation for a future where anyone—not just developers—can make AI agents useful in real-world systems.